"""K8s提取器配置管理模块"""

import os
import yaml
from typing import Any, Dict, List, Optional
import logging

class ConfigManager:
    """
    配置管理器
    负责读取和管理配置文件
    """
    
    # 默认配置
    DEFAULT_CONFIG = {
        'paths': {
            'source_dir': './sources',
            'output_dir': './outputs',
            'temp_dir': './temp',
        },
        'extraction': {
            'recursive': True,
            'include_kinds': [],
            'exclude_kinds': [],
            'file_extensions': ['.yaml', '.yml', '.json'],
            'preserve_directory_structure': True,
            'validate_resources': True,
        },
        'markdown': {
            'top_heading_level': 1,
            'include_raw_content': False,
            'generate_toc': True,
            'use_section_numbers': True,
            'link_style': 'relative',
            'table_display': 'auto',
            'fields': {
                'common': {
                    'show_namespace': True,
                    'show_annotations': True,
                    'show_labels': True,
                },
                'specific': {
                    'Deployment': {
                        'show_resources': True,
                        'show_env_vars': True,
                        'show_volumes': True,
                    },
                    'ConfigMap': {
                        'show_data': True,
                    },
                    'Secret': {
                        'show_data': False,
                    }
                }
            }
        },
        'logging': {
            'level': 'INFO',
            'file': '',
            'console': True,
            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            'max_size_mb': 10,
            'backup_count': 3,
        }
    }
    
    def __init__(self, config_file: str, logger: Optional[logging.Logger] = None):
        """
        初始化配置管理器
        
        Args:
            config_file: 配置文件路径
            logger: 日志记录器，可选
        """
        self.config_file = config_file
        self.logger = logger or logging.getLogger(__name__)
        self.config = {}
        
        # 加载配置
        self._load_config()
    
    def _create_default_config(self) -> None:
        """创建默认配置文件"""
        self.logger.info(f"创建默认配置文件: {self.config_file}")
        self.config = self.DEFAULT_CONFIG.copy()
        
        # 确保目录存在
        config_dir = os.path.dirname(os.path.abspath(self.config_file))
        os.makedirs(config_dir, exist_ok=True)
        
        # 写入配置文件
        with open(self.config_file, 'w', encoding='utf-8') as f:
            yaml.dump(self.config, f, default_flow_style=False, sort_keys=False)
    
    def _load_config(self) -> None:
        """加载配置文件，如果不存在则创建默认配置"""
        try:
            if os.path.exists(self.config_file):
                self.logger.info(f"加载配置文件: {self.config_file}")
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    self.config = yaml.safe_load(f) or {}
                # 合并默认配置确保所有项都存在
                self._merge_with_defaults()
            else:
                self.logger.warning(f"配置文件不存在，创建默认配置: {self.config_file}")
                self._create_default_config()
        except Exception as e:
            self.logger.error(f"加载配置文件失败: {str(e)}")
            self.logger.info("使用默认配置")
            self.config = self.DEFAULT_CONFIG.copy()
    
    def _merge_with_defaults(self) -> None:
        """将已加载的配置与默认配置合并，确保所有项都存在"""
        def _merge_dict(source, target):
            for key, value in source.items():
                if key not in target:
                    target[key] = value
                elif isinstance(value, dict) and isinstance(target[key], dict):
                    _merge_dict(value, target[key])
        
        _merge_dict(self.DEFAULT_CONFIG, self.config)
    
    def get(self, *keys, default=None):
        """
        获取配置项值
        
        Args:
            *keys: 配置路径，可以是多级
            default: 默认值，如果配置不存在则返回此值
            
        Returns:
            配置项值
        """
        try:
            result = self.config
            for key in keys:
                result = result[key]
            return result
        except (KeyError, TypeError):
            self.logger.warning(f"配置项不存在: {'.'.join(keys)}，使用默认值: {default}")
            return default
    
    def set(self, value, *keys) -> None:
        """
        设置配置项值
        
        Args:
            value: 要设置的值
            *keys: 配置路径，可以是多级
        """
        if not keys:
            return
            
        config = self.config
        for key in keys[:-1]:
            if key not in config or not isinstance(config[key], dict):
                config[key] = {}
            config = config[key]
            
        config[keys[-1]] = value
    
    def save(self) -> None:
        """保存配置到文件"""
        try:
            with open(self.config_file, 'w', encoding='utf-8') as f:
                yaml.dump(self.config, f, default_flow_style=False, sort_keys=False)
            self.logger.info(f"配置已保存到: {self.config_file}")
        except Exception as e:
            self.logger.error(f"保存配置失败: {str(e)}")
